added SSCLI 1.0

[windows-sources.git] / shared source / sscli20 / tools / nmake / action.cpp

// ==++==
//
//   
//    Copyright (c) 2006 Microsoft Corporation.  All rights reserved.
//   
//    The use and distribution terms for this software are contained in the file
//    named license.txt, which can be found in the root of this distribution.
//    By using this software in any fashion, you are agreeing to be bound by the
//    terms of this license.
//   
//    You must not remove this notice, or any other, from this software.
//   
//
// ==--==
//  ACTION.C -- routines called by the parser
//
// Purpose:
//  This module contains the routines called during parsing of a makefile.

#include "precomp.h"
#ifdef _MSC_VER 
#pragma hdrstop
#endif

void       startNameList(void);
void       makeRule(STRINGLIST *, BOOL fBatch);
void       makeTarget(char*, BOOL, BUILDBLOCK**);
void       appendPseudoTargetList(STRINGLIST**, STRINGLIST*);
void       clearSuffixes(void);
BOOL       doSpecial(char*);
BUILDLIST  * makeBuildList(BUILDBLOCK *);
char     * nextComponent(char **);

// created by endNameList() & freed by assignBuildCommands(). In use because
// although global 'list' has this list is used by too many routines and the
// complete sequence of actions on 'list' is unknown

STRINGLIST    * targetList;         // corr to a dependency block


//  makeName -- create copy of a name seen by lexer
//
// Purpose:
//  Create a copy of a macro or 1st name in a target/dependency list. It also
//  does the groundwork for expansion of macros in name and saves values.
//
// Assumes: That the lexical routines save the token in buf
//
// Modifies Globals:
//  name   -- the pointer to the copy created, gets allocated memory
//  macros -- the list of macro values in name. Used later by startNameList()
//           to expand macros in name and get expanded target name.
//
// Uses Globals:
//  buf    -- the lexical routines return a token in this
//
// Notes:
//  The token in buf could be part of a macrodefinition or a target list. The
//  next token determines if it is a macrodefn or a targetlist we are parsing.
//  The next token would overwrite the current token and so it is saved in name.

void
makeName()
{
    findMacroValues(buf, &macros, NULL, NULL, 0, 0, 0);
    name = makeString(buf);
}



void
addItemToList()
{
    STRINGLIST *p;                  // from lexer
    STRINGLIST *NewList;

    if (name) {
        SET(actionFlags, A_TARGET);
        startNameList();
        name = NULL;
    }
    if (ON(actionFlags, A_TARGET)) {
        if (isRule(buf)) {
            if (ON(actionFlags, A_RULE))
                makeError(currentLine, TOO_MANY_RULE_NAMES);
            makeError(currentLine, MIXED_RULES);
        }
    }
    p = makeNewStrListElement();
    if (ON(actionFlags, A_STRING)) {    // we collect macros
        p->text = string;               // for dependents &
        string = NULL;                  // build lines for
    } else                              // non-implicit rules
        p->text = makeString(buf);

    NewList = p;                        // build lines for
    if (OFF(actionFlags, A_RULE)        // rules get expanded
        || ON(actionFlags, A_TARGET))   // after entire make-
    {
        findMacroValues(p->text, &macros, NULL, NULL, 0, 0, 0); //  file parsed
    }

    if (ON(actionFlags, A_TARGET)) {
        p = macros;
        expandFileNames("$", &NewList, &macros);
        expandFileNames("*?", &NewList, NULL);
        while ((macros = p)) {
            p = p->next;
            FREE_STRINGLIST(macros);
        }
    }

    appendItem(&list, NewList);
}


//  startNameList -- puts in the first element into list
//
// Scope:           Local.
//
// Purpose:         Puts in the first name seen into a list
//
// Errors/Warnings: TARGET_MACRO_IS_NULL -- if the macro used as a target expands to null
//
// Assumes:
//  The global 'list' is originally a null list, & the global 'macro' points to
//  a list of values used for expanding the macros in global 'name'.
//
// Modifies Globals:
//  list    -- the list of names; set to contain the first name here or to a
//             list of values if 'name' contains a macro invocation.
//  macros  -- the list of values reqd for macro expansion; the list is
//             freed and macros is made NULL
//  currentFlags -- the flags for current target; set to global flags
//  actionFlags  -- determine actions to be done; if the name is a rule then set
//                  the rule bit
//
// Uses Globals:
//  name        -- the first name seen in a list of names.
//  flags       -- the global flags setup by the options specified
//  actionFlags -- if handling targets then no error as we have > 1 target
//
// Notes:
//  If there is more than one target then actionFlags has A_TARGET flag set and
//  startNameList() is called from addItemToList. In this case don't flag error.

void
startNameList()
{
    STRINGLIST *p;

    currentFlags = flags;               // set flags for cur target
    p = makeNewStrListElement();
    p->text = name;
    list = p;                           // list contains name
    p = macros;
    expandFileNames("$", &list, &macros);   // expand macros in name
    expandFileNames("*?", &list, NULL);     // expand wildcards
    while ((macros = p)) {          // free macro list
        p = p->next;
        FREE_STRINGLIST(macros);
    }
    if (!list && OFF(actionFlags, A_TARGET))
        makeError(line, TARGET_MACRO_IS_NULL, name);    // target null & 1 target

    if (list && isRule(list->text))
        SET(actionFlags, A_RULE);
}


//  endNameList -- semantic actions when a list is fully seen
//
// Purpose:
//  When the parser has seen an entire list then it needs to do some semantic
//  actions. It calls endNameList() to do these actions. The action depends on
//  the values in certain globals.
//
// Modifies Globals:    actionFlags --
//
// Uses Globals:
//  name         -- The first element seen (if non null)
//  actionFlags  -- The flag determining semantic & data structure actions
//  buf          -- The delimiter seen after list
//  list         -- The list of elements seen

void
endNameList()
{
    if (name) {                     // if only one name to left of :
        startNameList();            // it hasn't been put in list yet
        name = NULL;
    } else
        CLEAR(actionFlags, A_TARGET);       // clear target flag

    if (buf[1])
        SET(currentFlags, F2_DOUBLECOLON);  //  so addItemToList()

    if (!list)                                          //  won't expand names
        makeError(currentLine, SYNTAX_NO_TARGET_NAME);  //  of dependents

    if (ON(actionFlags, A_RULE)) {
                BOOL fBatch;
                // A rule with a doublecolon on the dependency line
                // is a "batch rule", i.e., a rule that applies the 
                // command block in batch mode for all affected 
                // dependents.  
        fBatch = !!(ON(currentFlags, F2_DOUBLECOLON));
        makeRule(list, fBatch);
        FREE_STRINGLIST(list);
    }
    else if (!(list->next) && doSpecial(list->text)) { // special pseudotarget ...
        FREE(list->text);           // don't need ".SUFFIXES" etc
        FREE_STRINGLIST(list);
    }
    else                            // regular target
        targetList = list;

    list = NULL;
    // We are now looking for a dependent
    SET(actionFlags, A_DEPENDENT);
}


BOOL
doSpecial(
    char *s)
{
    BOOL status = FALSE;

    if (!_tcsicmp(s, silent)) {
        SET(actionFlags, A_SILENT);
        setFlags('s', TRUE);
        status = TRUE;
    }

    if (!_tcsicmp(s, ignore)) {
        SET(actionFlags, A_IGNORE);
        setFlags('i', TRUE);
        status = TRUE;
    }
    else if (!_tcscmp(s, suffixes)) {
        SET(actionFlags, A_SUFFIX);
        status = TRUE;
    }
    else if (!_tcscmp(s, precious)) {
        SET(actionFlags, A_PRECIOUS);
        status = TRUE;
    }
    return(status);
}


void
expandFileNames(
    char *string,
    STRINGLIST **sourceList,
    STRINGLIST **macroList
    )
{
    char *s,
     *t = NULL;
    STRINGLIST *p;                  // Main list pointer
    STRINGLIST *pNew,               // Pointer to new list
               *pBack;              // Pointer to one element back
    char *saveText = NULL;

    for (pBack = NULL, p = *sourceList; p;) {

        // If no expand-character is found, continue to next list element.
        if (!_tcspbrk(p->text, string)) {
            pBack = p;
            p = pBack->next;
            continue;
        }

        // Either expand macros or wildcards.
        if (*string == '$') {
            t = expandMacros(p->text, macroList);
            FREE(p->text);
        } else {

            // If the wildcard string does not expand to anything, go to
            // next list elment.  Do not remove p from the original list
            // else we must check for null elsewhere.

            //                                   -- do not attempt to expand wildcards that
            // occur in inference rules

            if (isRule(p->text) || (pNew = expandWildCards(p->text)) == NULL) {
                pBack = p;
                p = pBack->next;
                continue;
            }
            saveText = p->text;
        }

        // At this point we have a list of expanded names to replace p with.
        if (pBack) {
            pBack->next = p->next;
            FREE_STRINGLIST(p);
            p = pBack->next;
        } else {
            *sourceList = p->next;
            FREE_STRINGLIST(p);
            p = *sourceList;
        }

        if (*string == '$') {       // if expanding macros
            char *str = t;
            if ((s = nextComponent(&str))) {
                do {                // put expanded names
                    pNew = makeNewStrListElement();     //  at front of list
                    pNew->text = makeString(s);         //  so we won't try to
                    prependItem(sourceList, pNew);      //  re-expand them
                    if (!pBack)
                        pBack = pNew;
                } while ((s = nextComponent(&str)));
            }
            FREE(t);
            continue;
        }
        else if (pNew) {            // if matches for * ?
            if (!pBack)
                for (pBack = pNew; pBack->next; pBack = pBack->next)
                    ;
            appendItem(&pNew, *sourceList);     // put at front of old list
            *sourceList = pNew;
        }
        FREE(saveText);
    }
}


//  nextComponent - returns next component from expanded name
//
// Scope:   Local (used by expandFilenames)
//
// Purpose:
//  Given a target string (target with macros expanded) this function returns a
//  name component. Previously _tcstok(s, " \t") was used but with the advent of
//  quoted filenames this is no good.
//
// Input:   szExpStr - the target name with macros expanded
//
// Output:  Returns pointer to next Component; NULL means no more components left.
//
// Assumes: That that two quoted strings are seperated by whitespace.

char *
nextComponent(
    char **szExpStr
    )
{
    char *t, *next;

    t = *szExpStr;

    while (WHITESPACE(*t))
        t++;

    next = t;
    if (!*t)
        return(NULL);

    if (*t == '"') {
        for (; *++t && *t != '"';)
            ;
    } else {
        for (; *t && *t != ' ' && *t != '\t'; t++)
            ;
    }

    if (WHITESPACE(*t)) {
        *t = '\0';
    } else if (*t == '"') {
        t++;
        if(*t=='\0') t--;   // If this is the end of the string, backup a byte, so we don't go past next time
            else *t = '\0';         // else stop here for this time.
    } else if (!*t) {
        // If at end of string then backup a byte so that next time we don't go past
        t--;
    }

    *szExpStr = t+1;
    return(next);
}


// append dependents to existing ones (if any)
void
assignDependents()
{
    const char *which = NULL;

    if (ON(actionFlags, A_DEPENDENT))
        CLEAR(actionFlags, A_DEPENDENT);

    if (ON(actionFlags, A_RULE)) {
        if (list)
            makeError(currentLine, DEPENDENTS_ON_RULE);
    }
    else if (ON(actionFlags, A_SILENT) || ON(actionFlags, A_IGNORE)) {
        if (list) {
            if (ON(actionFlags, A_SILENT))
                which = silent;
            else if (ON(actionFlags, A_IGNORE))
                which = ignore;
            makeError(currentLine, DEPS_ON_PSEUDO, which);
        }
    }
    else if (ON(actionFlags, A_SUFFIX)) {
        if (!list)
            clearSuffixes();
        else
            appendPseudoTargetList(&dotSuffixList, list);
    }
    else if (ON(actionFlags, A_PRECIOUS)) {
        if (list)
            appendPseudoTargetList(&dotPreciousList, list);
    }
    else {
        block = makeNewBuildBlock();
        block->dependents = list;
        block->dependentMacros = macros;
    }
    list = NULL;
    macros = NULL;
    SET(actionFlags, A_STRING);             // expecting build cmd
}

void
assignBuildCommands()
{
    BOOL okToFreeList = TRUE;
    BOOL fFirstTarg = (BOOL)TRUE;
    STRINGLIST *p;
    const char *which = NULL;

    if (ON(actionFlags, A_RULE))        // no macros found yet for inference rules
        rules->buildCommands = list;
    else if (ON(actionFlags, A_SILENT) ||
             ON(actionFlags, A_IGNORE) ||
             ON(actionFlags, A_PRECIOUS) ||
             ON(actionFlags, A_SUFFIX)
            ) {
        if (list) {
            if (ON(actionFlags, A_SILENT))
                which = silent;
            else if (ON(actionFlags, A_IGNORE))
                which = ignore;
            else if (ON(actionFlags, A_PRECIOUS))
                which = precious;
            else if (ON(actionFlags, A_SUFFIX))
                which = suffixes;
            makeError(currentLine, CMDS_ON_PSEUDO, which);
        }
    } else {
        block->buildCommands = list;
        block->buildMacros = macros;
        block->flags = currentFlags;
        while ((p = targetList)) {              // make a struct for each targ
            if (doSpecial(p->text))                     // in list, freeing list when
                makeError(currentLine, MIXED_TARGETS);
            makeTarget(p->text, fFirstTarg, &block);    // done, don't free name
            if (!makeTargets) {                         // field -- it's still in use
                makeTargets = p;                        // if no targs given on cmdlin
                okToFreeList = FALSE;                   // put first target(s) from
            }                                           // mkfile in makeTargets list
            targetList =  p->next;                      // (makeTargets defined in
            if (okToFreeList)                           // nmake.c)
                FREE_STRINGLIST(p);
            if (fFirstTarg)
                fFirstTarg = (BOOL)FALSE;
        }
    }
    targetList = NULL;
    list = NULL;
    macros = NULL;
    block = NULL;
    actionFlags = 0;
}

//  makeMacro -- define macro with name and string taken from global variables
//
// Modifies:
//  fInheritUserEnv    set to TRUE
//
// Notes:
//  Calls putMacro() to place expanded Macros in the NMAKE table. By setting
//  fInheritUserEnv those definitions that change Environment variables are
//  inherited by the environment.

void
makeMacro()
{
    STRINGLIST *q;
    char *t;

    if (_tcschr(name, '$')) {              // expand name
        q = macros;
        t = expandMacros(name, &macros);    // name holds result
        if (!*t)                            // error if macro to left of = is undefined
            makeError(currentLine, SYNTAX_NO_MACRO_NAME);
        while ((macros = q)) {
            q = q->next;
            FREE_STRINGLIST(macros);
        }
        FREE(name);
        name = t;
    }

    for (t = name; *t && MACRO_CHAR(*t); t = _tcsinc (t))   // Check for illegal chars
        ;

    if (*t)
        makeError(currentLine, SYNTAX_BAD_CHAR, *t);

    fInheritUserEnv = (BOOL)TRUE;

    // Put Env Var in Env & macros in table.

    if (!putMacro(name, string, 0)) {
        FREE(name);
        FREE(string);
    }
    name = string = NULL;
}


//  defineMacro -- check macro's syntax for illegal chars., then define it
//
//  actions:    check all of macro's characters
//        if one's bad and it's an environment macro, bag it
//            else flag error
//        call putMacro to do the real work
//
// can't use macro invocation to left of = in macro def from commandline
//  it doesn't make sense to do that, because we're not in a makefile
//  the only way to get a comment char into the makefile w/o having it really
//  mark a comment is to define a macro A=# on the command line

BOOL
defineMacro(
    char *s,                        // commandline or env definitions
    char *t,
    UCHAR flags
    )
{
    char *u;

    for (u = s; *u && MACRO_CHAR(*u); u = _tcsinc(u))  // check for illegal
        ;
    if (*u) {
        if (ON(flags, M_ENVIRONMENT_DEF)) { // ignore bad macros
            return(FALSE);
        }
        makeError(currentLine, SYNTAX_BAD_CHAR, *u);    // chars,  bad syntax
    }
    return(putMacro(s, t, flags));          // put macro in table
}


//  putMacro - Put the macro definition into the Macro Table / Environmnet
//
// Scope:
//  Global.
//
// Purpose:
//  putMacro() inserts a macro definition into NMAKE's macro table and also into
//  the environment. If a macro name is also an environment variable than its
//  value is inherited into the environment. While replacing older values by new
//  values NMAKE needs to follow the precedence of macro definitions which is
//  as per the notes below.
//
// Input:
//  name  - Name of the macro
//  value - Value of the macro
//  flags - Flags determining Precedence of Macro definitions (see Notes)
//
// Output:
//
// Errors/Warnings:
//  OUT_OF_ENV_SPACE - If putenv() returns failure in adding to the environment.
//
// Assumes:
//  Whatever it assumes
//
// Modifies Globals:
//  fInheritUserEnv - Set to False.
//
// Uses Globals:
//  fInheritUserEnv  - If True then Inherit definition to the Environment.
//  gFlags           - Global Options Flag. If -e specified then Environment Vars
//                       take precedence.
//  macroTable       - NMAKE's internal table of Macro Definitions.
//
// Notes:
//  1> If the same macro is defined in more than one place then NMAKE uses the
//     following order of Precedence (highest to lowest) --
//
//     -1- Command line definitions
//     -2- Description file/Include file definitions
//     -3- Environment definitions
//     -4- TOOLS.INI definitions
//     -5- Predefined Values (e.g. for CC, AS, BC, RC)
//     If -e option is specified then -3- precedes -2-.
//
//  2> Check if the macro already exists in the Macro Table. If the macro is not
//     redefinable (use order of precedence) then return. Make a new string
//     element to hold macro's new value. If the macro does not exist then create
//     new entry in the Macro table. Set Macro's flag to be union of Old and new
//     values. Add the new value to macro's value entry. If a new macro then add
//     it to the macro table. Test for Cyclic definitions.

BOOL
putMacro(
    char *name,
    char *value,
    UCHAR flags
    )
{
    MACRODEF *p;
    STRINGLIST *q;
    BOOL defined = FALSE;
    BOOL fSyntax = TRUE;

    // Convert path separators to the native path separator.
    // Do that with a copy of the original string so we don't change
    // the original.
    value = makeString(value);
#if PLATFORM_UNIX
    char *tmp = value;
    while ((tmp = FindFirstPathSeparator(tmp))) {
        *tmp++ = PATH_SEPARATOR_CHAR;
    }
#endif


    if (ON(flags, M_NON_RESETTABLE)) {
        if (*value)
            if ((putEnvStr(name,removeMacros(value)) == -1))
                makeError(currentLine, OUT_OF_ENV_SPACE);
    } else
    if (fInheritUserEnv &&
        OFF(gFlags, F1_USE_ENVIRON_VARS) &&
        getenv(name)
       ) {
        if ((p = findMacro(name))) {  // don't let user
            if (CANT_REDEFINE(p))   // redefine cmdline
                return(FALSE);      // macros, MAKE, etc.
        }
        if ((putEnvStr(name,removeMacros(value)) == -1))
            makeError(currentLine, OUT_OF_ENV_SPACE);
    }

    fInheritUserEnv = (BOOL)FALSE;
    if ((p = findMacro(name))) {      // don't let user
        if (CANT_REDEFINE(p))       // redefine cmdline
            return(FALSE);          // macros, MAKE, etc.
    }

    q = makeNewStrListElement();
    q->text = value;

    if (!p) {
        p = makeNewMacro();
        p->name = name;
        assert(p->flags == 0);
        assert(p->values == NULL);
    } else
        defined = TRUE;

    p->flags &= ~M_UNDEFINED;       // Is no longer undefined
    p->flags |= flags;              // Set flags to union of old and new
    prependItem((STRINGLIST**)&(p->values), (STRINGLIST*)q);
    if (!defined)
        insertMacro((STRINGLIST*)p);

    if (OFF(flags, M_LITERAL) && _tcschr(value, '$')) {     // Check for cyclic Macro Definitions
        SET(p->flags, M_EXPANDING_THIS_ONE);
        // NULL -> don't build list
        fSyntax = findMacroValues(value, NULL, NULL, name, 1, 0, flags);
        CLEAR(p->flags, M_EXPANDING_THIS_ONE);
    }

    if (!fSyntax) {
        p->values = NULL;
        p->flags |= M_UNDEFINED;
        //return(FALSE);
                // return TRUE since p has been added to the macro table
                // Otherwise the caller may free name and value leaving
                // dangling pointers in the macro table.                            
                return(TRUE);
    }
    return(TRUE);
}


//  makeRule -- makes an inference rule
//
// Scope:
//  Local
//
// Purpose:
//  Allocates space for an inference rule and adds rule to the beginning of the
//  doubly linked inference rule list. The name of the rule is also added.
//
// Input:
//  rule -- The name of the inference rule
//      fBatch -- True if command block should be executed in batch mode
//
// Output:
//
// Errors/Warnings:
//
// Assumes:
//
// Modifies Globals:
//  rules -- The doubly linked inference rule list to which the rule is added
//
// Uses Globals:
//
// Notes:
//  The syntax of an inference rule is --
//
//  {frompath}.fromext{topath}.toext:    # Name of the inference rule
//      command ...                      # command block of the inference rule

void
makeRule(
    STRINGLIST *rule,
        BOOL fBatch
    )
{
    RULELIST *rList;

    rList = makeNewRule();
    rList->name = rule->text;
    
#if PLATFORM_UNIX
    // Convert path separators to the native path separator.
    char *tmp = rList->name;
    while ((tmp = FindFirstPathSeparator(tmp))) {
        *tmp++ = PATH_SEPARATOR_CHAR;
    }
#endif // PLATFORM_UNIX
    
    rList->fBatch = fBatch;
    prependItem((STRINGLIST**)&rules, (STRINGLIST*)rList);
    if (rList->next)
        rList->next->back = rList;
}


//  makeTarget -- add target to targetTable
//
//  actions:    if no block defined, create one and initialize it
//        make new build list entry for this target
//        if the target's already in the table,
//            flag error if : and :: mixed
//            else add new buildlist object to target's current buildlist
//        else allocate new object, initialize it, and stick it in table

void
makeTarget(
    char *s,
    BOOL firstTarg,
    BUILDBLOCK **block
    )
{
    BUILDLIST  *build;
    MAKEOBJECT *object;

    if (!*block)
        *block = makeNewBuildBlock();

    if (firstTarg) {
        build = makeNewBldListElement();
        build->buildBlock = *block;
    } else
        build = makeBuildList(*block);

    if ((object = findTarget(s))) {
        if (ON(object->flags2, F2_DOUBLECOLON) != ON(currentFlags, F2_DOUBLECOLON))
            makeError(currentLine, MIXED_SEPARATORS);
        appendItem((STRINGLIST**)&(object->buildList), (STRINGLIST*)build);
        FREE(s);
    } else {
        build->next = NULL;
        object = makeNewObject();
        object->name = s;
        object->buildList = build;
        object->flags2 = currentFlags;
        prependItem((STRINGLIST**)targetTable+hash(s, MAXTARGET, (BOOL)TRUE),
                    (STRINGLIST*)object);
    }
}


void
clearSuffixes()
{
    STRINGLIST *p;

    while ((p = dotSuffixList)) {
    dotSuffixList = dotSuffixList->next;
    FREE(p->text);
    FREE_STRINGLIST(p);
    }
}


void
appendPseudoTargetList(
    STRINGLIST **pseudo,
    STRINGLIST *list
    )
{
    STRINGLIST  *p, *q, *r;
    char *t, *u;

    while ((p = list)) {
        if (!_tcschr(p->text, '$')) {
            list = list->next;
            p->next = NULL;
            appendItem(pseudo, p);
        } else {
            r = macros;
            t = expandMacros(p->text, &macros);
            while (r != macros) {
                q = r->next;
                FREE_STRINGLIST(r);
                r = q;
            }
            for (u = _tcstok(t, " \t"); u; u = _tcstok(NULL, " \t")) {
                q = makeNewStrListElement();
                q->text = makeString(u);
                appendItem(pseudo, q);
            }
            FREE(t);
            FREE(p->text);
            list = list->next;
            FREE_STRINGLIST(p);
        }
    }
}

//  putEnvStr -- Extends putenv() standard function
//
// Purpose:
//  Library function putenv() expects one string argument of the form
//    "NAME=value"
//  Most of the times when putenv() is to be used we have two strings
//    name   -- of the variable to add to the environment, and
//    value  -- to be set
//  putEnvStr takes these 2 parameters and calls putenv with the reqd
//  format
//
// Input:
//  name  -- of var to add to the env
//  value -- reqd to be set
//
// Output:
//  Same as putenv()

int
putEnvStr(
    char *name,
    char *value
    )
{
    BOOL b = SetEnvironmentVariableA(name, value);

    return (b) ? 0 : -1;
}


//  makeBuildList -- takes a build block and copies into a buildlist
//
// Purpose:
//  Routine creates a copy of a buildlist and returns a pointer to a copy.
//  When multiple targets have the same description block then there is a
//  need for each of them to get seperate build blocks. makeBuildList()
//  helps achieve this by creating a copy for each target.
//
// Input:
//  bBlock  --  the build block whose copy is to be added to a build block
//
// Output:
//  Returns a pointer to the copy of buildlist it creates

BUILDLIST *
makeBuildList(
    BUILDBLOCK *bBlock
    )
{
    BUILDLIST *tList = makeNewBldListElement();
    BUILDBLOCK *tBlock = makeNewBuildBlock();

    tBlock->dependents = bBlock->dependents;
    tBlock->dependentMacros = bBlock->dependentMacros;
    tBlock->buildCommands = bBlock->buildCommands;
    tBlock->buildMacros = bBlock->buildMacros;
    tBlock->flags = bBlock->flags;
    tBlock->dateTime = bBlock->dateTime;

    tList->buildBlock = tBlock;
    return(tList);
}